package handler

import (
	"net/http"
	"time"

	"github.com/gin-gonic/gin"

	"hrms-api/model"
)

// InterviewRequest 面试请求结构
type InterviewRequest struct {
	CandidateID  uint      `json:"candidate_id" binding:"required"`
	PositionID   uint      `json:"position_id" binding:"required"`
	ScheduleTime time.Time `json:"schedule_time" binding:"required"`
	Location     string    `json:"location" binding:"required"`
	Type         int       `json:"type" binding:"required"` // 1-初试, 2-复试, 3-终试
	Notes        string    `json:"notes"`
}

// InterviewStatusRequest 面试状态更新请求结构
type InterviewStatusRequest struct {
	Status int    `json:"status" binding:"required,oneof=1 2 3"` // 1-待面试，2-已完成，3-已取消
	Reason string `json:"reason,omitempty"`                      // 状态变更原因，可选
}

// InterviewFeedbackRequest 面试反馈请求结构
type InterviewFeedbackRequest struct {
	Feedback string  `json:"feedback" binding:"required"` // 面试反馈内容
	Score    float32 `json:"score" binding:"required"`    // 面试评分
	Result   int     `json:"result" binding:"required"`   // 面试结果：1-通过，2-待定，3-不通过
}

// CreateInterview 创建面试
func CreateInterview(c *gin.Context) {
	// 检查权限（只有HR或管理员可以创建面试）
	userRole, exists := c.Get("role")
	if !exists || (userRole != "hr" && userRole != "admin") {
		Forbidden(c, "需要HR或管理员权限")
		return
	}

	var req InterviewRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, err.Error())
		return
	}

	// 创建面试记录
	interview := model.Interview{
		CandidateID:  req.CandidateID,
		PositionID:   req.PositionID,
		ScheduleTime: req.ScheduleTime,
		Location:     req.Location,
		Type:         req.Type,
		Notes:        req.Notes,
		Status:       1, // 1-待进行
	}

	if err := model.DB.Create(&interview).Error; err != nil {
		InternalServerError(c, err.Error())
		return
	}

	Success(c, interview)
}

// UpdateInterview 更新面试信息
func UpdateInterview(c *gin.Context) {
	// 检查权限（只有HR或管理员可以更新面试）
	userRole, exists := c.Get("role")
	if !exists || (userRole != "hr" && userRole != "admin") {
		Forbidden(c, "需要HR或管理员权限")
		return
	}

	id := c.Param("id")
	var interview model.Interview

	if err := model.DB.First(&interview, id).Error; err != nil {
		NotFound(c, "面试记录不存在")
		return
	}

	var req InterviewRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, err.Error())
		return
	}

	// 更新面试信息
	interview.ScheduleTime = req.ScheduleTime
	interview.Location = req.Location
	interview.Type = req.Type
	interview.Notes = req.Notes

	if err := model.DB.Save(&interview).Error; err != nil {
		InternalServerError(c, err.Error())
		return
	}

	Success(c, interview)
}

// GetInterview 获取面试详情
func GetInterview(c *gin.Context) {
	id := c.Param("id")
	var interview model.Interview

	if err := model.DB.First(&interview, id).Error; err != nil {
		NotFound(c, "面试记录不存在")
		return
	}

	Success(c, interview)
}

// ListInterviews 获取面试列表
func ListInterviews(c *gin.Context) {
	var interviews []model.Interview
	query := model.DB.Model(&model.Interview{})

	// 支持按状态筛选
	if status := c.Query("status"); status != "" {
		query = query.Where("status = ?", status)
	}

	// 支持按面试类型筛选
	if interviewType := c.Query("type"); interviewType != "" {
		query = query.Where("type = ?", interviewType)
	}

	// 支持按日期范围筛选
	if startDate := c.Query("start_date"); startDate != "" {
		query = query.Where("schedule_time >= ?", startDate)
	}
	if endDate := c.Query("end_date"); endDate != "" {
		query = query.Where("schedule_time <= ?", endDate)
	}

	// 支持按候选人ID筛选
	if candidateID := c.Query("candidate_id"); candidateID != "" {
		query = query.Where("candidate_id = ?", candidateID)
	}

	// 支持按职位ID筛选
	if positionID := c.Query("position_id"); positionID != "" {
		query = query.Where("position_id = ?", positionID)
	}

	// 支持按时间范围筛选（兼容旧版API）
	if startTime := c.Query("start_time"); startTime != "" && c.Query("start_date") == "" {
		query = query.Where("schedule_time >= ?", startTime)
	}
	if endTime := c.Query("end_time"); endTime != "" && c.Query("end_date") == "" {
		query = query.Where("schedule_time <= ?", endTime)
	}

	if err := query.Find(&interviews).Error; err != nil {
		Error(c, http.StatusInternalServerError, err.Error())
		return
	}

	Success(c, interviews)
}

// DeleteInterview 删除面试记录
func DeleteInterview(c *gin.Context) {
	// 检查权限（只有HR或管理员可以删除面试记录）
	userRole, exists := c.Get("role")
	if !exists || (userRole != "hr" && userRole != "admin") {
		Forbidden(c, "需要HR或管理员权限")
		return
	}

	id := c.Param("id")
	var interview model.Interview

	if err := model.DB.First(&interview, id).Error; err != nil {
		NotFound(c, "面试记录不存在")
		return
	}

	// 删除面试记录
	if err := model.DB.Delete(&interview).Error; err != nil {
		InternalServerError(c, err.Error())
		return
	}

	Success(c, gin.H{
		"message": "面试记录已删除",
	})
}

// UpdateInterviewStatus 更新面试状态
func UpdateInterviewStatus(c *gin.Context) {
	id := c.Param("id")
	var interview model.Interview

	if err := model.DB.First(&interview, id).Error; err != nil {
		NotFound(c, "Interview not found")
		return
	}

	type StatusUpdate struct {
		Status int `json:"status" binding:"required"`
	}

	var update StatusUpdate
	if err := c.ShouldBindJSON(&update); err != nil {
		BadRequest(c, "Invalid request payload")
		return
	}

	// 更新状态
	interview.Status = update.Status

	if err := model.DB.Save(&interview).Error; err != nil {
		InternalServerError(c, err.Error())
		return
	}

	Success(c, interview)
}

// SubmitInterviewResult 提交面试结果
func SubmitInterviewResult(c *gin.Context) {
	id := c.Param("id")
	var interview model.Interview

	if err := model.DB.First(&interview, id).Error; err != nil {
		NotFound(c, "Interview not found")
		return
	}

	// 检查权限（只有HR或管理员可以提交面试结果）
	userRole, exists := c.Get("role")
	if !exists || (userRole != "hr" && userRole != "admin") {
		Forbidden(c, "需要HR或管理员权限")
		return
	}

	type ResultRequest struct {
		Score      float32 `json:"score" binding:"required"`
		Evaluation string  `json:"evaluation" binding:"required"`
		Result     int     `json:"result" binding:"required"`
		Notes      string  `json:"notes"`
	}

	var req ResultRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, "Invalid request payload")
		return
	}

	// 更新面试结果
	interview.Score = req.Score
	interview.Evaluation = req.Evaluation
	interview.Result = req.Result
	interview.Notes = req.Notes
	interview.Status = 2 // 已完成

	if err := model.DB.Save(&interview).Error; err != nil {
		InternalServerError(c, err.Error())
		return
	}

	Success(c, interview)
}

// CompleteInterview 完成面试
func CompleteInterview(c *gin.Context) {
	// 检查权限（只有HR或管理员可以标记面试完成）
	userRole, exists := c.Get("role")
	if !exists || (userRole != "hr" && userRole != "admin") {
		Forbidden(c, "需要HR或管理员权限")
		return
	}

	id := c.Param("id")
	var interview model.Interview

	if err := model.DB.First(&interview, id).Error; err != nil {
		NotFound(c, "面试记录不存在")
		return
	}

	// 更新面试状态为已完成
	interview.Status = 2 // 2-已完成

	if err := model.DB.Save(&interview).Error; err != nil {
		InternalServerError(c, err.Error())
		return
	}

	Success(c, gin.H{
		"message": "面试已标记为完成",
	})
}

// AddFeedback 添加面试反馈
func AddFeedback(c *gin.Context) {
	// 检查权限（只有HR或管理员可以添加面试反馈）
	userRole, exists := c.Get("role")
	if !exists || (userRole != "hr" && userRole != "admin") {
		Forbidden(c, "需要HR或管理员权限")
		return
	}

	// 获取面试ID
	id := c.Param("id")
	var interview model.Interview

	if err := model.DB.First(&interview, id).Error; err != nil {
		NotFound(c, "面试记录不存在")
		return
	}

	// 检查面试状态
	if interview.Status != 1 { // 1-待面试
		BadRequest(c, "当前面试状态不允许添加反馈")
		return
	}

	// 解析请求体
	var req InterviewFeedbackRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		BadRequest(c, err.Error())
		return
	}

	// 更新面试反馈信息
	updates := map[string]interface{}{
		"feedback": req.Feedback,
		"score":    req.Score,
		"result":   req.Result,
		"status":   2, // 更新状态为已完成
	}

	// 执行更新
	if err := model.DB.Model(&interview).Updates(updates).Error; err != nil {
		InternalServerError(c, err.Error())
		return
	}

	Success(c, gin.H{"message": "面试反馈添加成功"})
}
